package writtenTraining.day33;

import java.util.*;

/**
 * day33(1)找规律+模拟：DP3 跳台阶扩展问题
 */

public class Main {
    public static void main(String[] args) {
        // 模拟 + 找规律

        // 输入数据
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int ret = 1;
        for(int i = 1; i < n; i++) {
            ret *= 2;
        }


        System.out.println(ret);
    }
}


/**
 * day33:(2)滑动窗口:NC402 包含不超过两种字符的最长子串
 */


 class Main1 {
    public static void main(String[] args) {
        // 滑动窗口

        // 输入数据
        Scanner in = new Scanner(System.in);
        char[] chs = in.next().toCharArray();
        int len = chs.length;
        Map<Character,Integer> map = new HashMap<>();

        int ret = -0x3f3f3f3f;
        for(int left = 0, right = 0; right < len; right++) {
            // 入窗口
            map.put(chs[right], map.getOrDefault(chs[right],0) + 1);

            // 出窗口
            while(map.size() > 2) {
                char ch = chs[left];
                map.put(ch,map.get(ch) - 1);
                if(map.get(ch) <= 0) {
                    map.remove(ch);
                }
                left++;
            }

            // 更新结果
            ret = Math.max(ret,right - left + 1);
        }

        // 输出结果
        System.out.println(ret);
    }
}


/**
 * day33:(3)排序+dfs:JZ38 字符串的排列
 */


class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param str string字符串
     * @return string字符串ArrayList
     */
    public  ArrayList<String> ret;
    public int n ;
    public StringBuilder s;
    public boolean[] path;
    public ArrayList<String> Permutation (String str) {
        // 排序 + dfs
        ret = new ArrayList<>();
        n = str.length();
        s = new StringBuilder();
        path = new boolean[n];
        char[] chs = str.toCharArray();
        // 排序
        Arrays.sort(chs);
        dfs(chs,0);

        return ret;
    }

    private void dfs(char[] chs , int pos) {
        // 统计结果
        if(pos == n ) {
            ret.add(s.toString());
            return;
        }

        for(int i = 0; i < n; i++) {
            // 排除使用过的
//            该字符是否使用过
            if(path[i]) continue;

//            去重， 如果是 a a 的情况
            if(i > 0 &&
                    chs[i - 1] == chs[i]
                    && !path[i-1])
                continue;


            path[i] = true;
            s.append(chs[i]);
            // 下一层
            dfs(chs,pos+1);
            // 回溯
            s.deleteCharAt(s.length()- 1);
            path[i] = false;

        }
    }


}